"""
AI Chat应用工具函数
包含加密解密、数据处理等通用功能
"""

import base64
import json
from typing import Any, Dict, Optional
from django.conf import settings
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC


def get_encryption_key() -> bytes:
    """
    获取加密密钥
    基于Django SECRET_KEY生成固定的加密密钥
    """
    password = settings.SECRET_KEY.encode()
    salt = b'ai_chat_salt_2024'  # 固定盐值，确保密钥一致性
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        iterations=100000,
    )
    key = base64.urlsafe_b64encode(kdf.derive(password))
    return key


def encrypt_api_key(api_key: str) -> str:
    """
    加密API密钥
    
    Args:
        api_key: 原始API密钥
        
    Returns:
        加密后的API密钥（Base64编码）
    """
    if not api_key:
        return ""
    
    try:
        key = get_encryption_key()
        f = Fernet(key)
        encrypted_key = f.encrypt(api_key.encode())
        return base64.b64encode(encrypted_key).decode()
    except Exception as e:
        # 如果加密失败，返回Base64编码的原始密钥（向后兼容）
        return base64.b64encode(api_key.encode()).decode()


def decrypt_api_key(encrypted_api_key: str) -> str:
    """
    解密API密钥
    
    Args:
        encrypted_api_key: 加密的API密钥
        
    Returns:
        解密后的原始API密钥
    """
    if not encrypted_api_key:
        return ""
    
    try:
        # 首先尝试使用Fernet解密
        key = get_encryption_key()
        f = Fernet(key)
        encrypted_data = base64.b64decode(encrypted_api_key.encode())
        decrypted_key = f.decrypt(encrypted_data)
        return decrypted_key.decode()
    except Exception:
        try:
            # 如果Fernet解密失败，尝试Base64解码（向后兼容）
            return base64.b64decode(encrypted_api_key.encode()).decode()
        except Exception:
            # 如果都失败了，返回原始字符串
            return encrypted_api_key


def mask_api_key(api_key: str, show_chars: int = 4) -> str:
    """
    脱敏API密钥，只显示最后几位
    
    Args:
        api_key: API密钥
        show_chars: 显示的字符数
        
    Returns:
        脱敏后的API密钥
    """
    if not api_key or len(api_key) <= show_chars:
        return "****"
    
    return "****" + api_key[-show_chars:]


def validate_json_params(params: Any) -> Dict[str, Any]:
    """
    验证和清理JSON参数
    
    Args:
        params: 参数对象
        
    Returns:
        清理后的参数字典
    """
    if not params:
        return {}
    
    if isinstance(params, str):
        try:
            return json.loads(params)
        except json.JSONDecodeError:
            return {}
    
    if isinstance(params, dict):
        return params
    
    return {}


def format_response_time(seconds: float) -> str:
    """
    格式化响应时间
    
    Args:
        seconds: 秒数
        
    Returns:
        格式化的时间字符串
    """
    if seconds < 1:
        return f"{int(seconds * 1000)}ms"
    else:
        return f"{seconds:.2f}s"


def extract_error_message(error: Exception) -> str:
    """
    从异常中提取友好的错误消息
    
    Args:
        error: 异常对象
        
    Returns:
        友好的错误消息
    """
    error_str = str(error).lower()
    
    # 常见错误类型映射
    error_mappings = {
        'connection': '网络连接失败',
        'timeout': '请求超时',
        'unauthorized': '认证失败，请检查API密钥',
        'forbidden': '权限不足',
        'not found': '接口不存在',
        'rate limit': '请求频率超限',
        'quota': '配额不足',
        'invalid': '参数无效',
    }
    
    for key, message in error_mappings.items():
        if key in error_str:
            return message
    
    return str(error)


def calculate_token_cost(input_tokens: int, output_tokens: int, 
                        input_price: float, output_price: float) -> float:
    """
    计算Token使用费用
    
    Args:
        input_tokens: 输入Token数量
        output_tokens: 输出Token数量
        input_price: 输入Token单价（每1000个Token）
        output_price: 输出Token单价（每1000个Token）
        
    Returns:
        总费用
    """
    input_cost = (input_tokens / 1000) * input_price
    output_cost = (output_tokens / 1000) * output_price
    return round(input_cost + output_cost, 6)


def parse_ai_response(response_data: Dict[str, Any], provider_type: str) -> Dict[str, Any]:
    """
    解析不同AI提供商的响应数据
    
    Args:
        response_data: 原始响应数据
        provider_type: 提供商类型
        
    Returns:
        标准化的响应数据
    """
    if provider_type == 'openai':
        return {
            'content': response_data.get('choices', [{}])[0].get('message', {}).get('content', ''),
            'model': response_data.get('model', ''),
            'usage': response_data.get('usage', {}),
            'finish_reason': response_data.get('choices', [{}])[0].get('finish_reason', '')
        }
    elif provider_type == 'anthropic':
        return {
            'content': response_data.get('content', [{}])[0].get('text', ''),
            'model': response_data.get('model', ''),
            'usage': response_data.get('usage', {}),
            'finish_reason': response_data.get('stop_reason', '')
        }
    elif provider_type == 'google':
        candidates = response_data.get('candidates', [])
        content = ''
        if candidates:
            parts = candidates[0].get('content', {}).get('parts', [])
            if parts:
                content = parts[0].get('text', '')
        
        return {
            'content': content,
            'model': 'gemini-pro',
            'usage': response_data.get('usageMetadata', {}),
            'finish_reason': candidates[0].get('finishReason', '') if candidates else ''
        }
    else:
        # 自定义提供商，尝试通用解析
        return {
            'content': str(response_data),
            'model': 'custom',
            'usage': {},
            'finish_reason': 'unknown'
        }
